home *** CD-ROM | disk | FTP | other *** search
/ Computer Music Interactif…cial Edition 1999 Winter / cd 3.iso / mac / Mac / Shares / Midishare™1.68 / Development Tools / MIDIShareUnit.p < prev   
Encoding:
Text File  |  1993-03-24  |  24.1 KB  |  579 lines  |  [TEXT/MPS ]
  1. {••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••}
  2. {•                                MIDI SHARE                                    •}
  3. {•------------------------------------------------------------------------------•}
  4. {• MIDISHARE est un module logiciel conçu spécialement pour permettre le fonc-    •}
  5. {• tionnement et le développement d'applications Midi dans un contexte multi-    •}
  6. {• tâches et temps réel.                                                         •}
  7. {•                                                                                 •}
  8. {• MIDISHARE prend en charge la plupart des problèmes spécifiques liés au déve- •}
  9. {• loppement d'applications Midi: gestion des flux Midi, gestion du temps,        •}
  10. {• gestion des tâches. En outre, MIDISHARE permet le fonctionnement simultané    •}
  11. {• sous Multi-Finder de ces applications, ainsi que l'établissement de connec-    •}
  12. {• tions Midi virtuelles entre celles-ci.                                        •}
  13. {•                                                                                 •}
  14. {• Le présent fichier décrit les points d'entrée de MIDISHARE, ainsi que les     •}
  15. {• structures de données et les constantes utilisées. Le code MIDISHARE propre-    •}
  16. {• ment dit est contenu dans le fichier MidiShareI, une    INIT qui doit être pla-    •}
  17. {• cée dans le dossier Système. Au démarrage de la machine, ce code est chargé    •}
  18. {• en mémoire et il est "ancré" au vecteur $B8. Toutes les fonctions et les     •}
  19. {• procédures définies ici se servent de cette "ancre" pour accéder au code.    •}
  20. {•------------------------------------------------------------------------------•}
  21. {•        © GRAME 1989/90, Yann Orlarey et Hervé Lequay                            •}
  22. {••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••}
  23.  
  24.  
  25. UNIT MIDIShareUnit;
  26.  
  27.  
  28.     
  29. INTERFACE
  30.  
  31. uses    MemTypes;
  32.  
  33. Const    
  34.  
  35. (********************************************************************************)
  36. (*                             TYPES D'EVENEMENTS                                    *)
  37. (*------------------------------------------------------------------------------*)
  38. (* Constantes définissant les types d'événements manipulés par MidiShare. Cette *)
  39. (* typologie inclue bien entendu les différents types Midi, mais aussi d'au-    *)
  40. (* tres catégories d'événements, en particulier les Notes, les Streams, les     *)
  41. (* Process et les types privés. Ces codes sont à utiliser entre autre avec la     *)
  42. (* fonction NewMidiEv.                                                             *)
  43. (********************************************************************************)
  44.             
  45.         typeNote        =     0;                    { note avec hauteur, vélocité et durée en ms    }    
  46.         
  47.         typeKeyOn        =    1;                    { Note On avec hauteur et vélocité                 }
  48.         typeKeyOff        =     2;                    { Note Off avec hauteur et vélocité                }
  49.         typeKeyPress     =    3;                    { Poly KeyPress avec hauteur et pression        }
  50.         typeCtrlChange    =    4;                    { Control Change avec controleur et valeur        }
  51.         typeProgChange    =    5;                    { Program Change avec numéro de programme        }
  52.         typeChanPress    =    6;                    { Channel Pressure avec pression                }
  53.         typePitchWheel    =    7;                    { Pitch Wheel Change avec LSB et MSB            }
  54.         
  55.         typeSongPos        =    8;                    { Song Position Pointer avec LSB et MSB            }
  56.         typeSongSel        =    9;                    { Song Select avec numéro de song                }
  57.         typeClock        =    10;                    { Timing Clock                                    }
  58.         typeStart        =    11;                    { Start                                            }
  59.         typeContinue    =    12;                    { Continue                                        }
  60.         typeStop        =    13;                    { Stop                                            }
  61.         
  62.         typeTune        =    14;                    { Tune Request                                    }
  63.         typeActiveSens    =    15;                    { Active Sensing                                }
  64.         typeReset        =    16;                    { System Reset                                    }
  65.         
  66.         typeSysEx        =    17;                    { System Exclusive de longueur variable            }
  67.         typeStream        =    18;                    { Flot Midi quelconque de longueur variable        }
  68.         
  69.         typePrivate        =    19;     {19..127}    { Evénement privé à usage libre pour l'appl        }
  70.         typeProcess        =    128;                { Evénement privé servant au MidiTask            }
  71.         typeDProcess    =    129;                { Evénement privé servant au MidiDTask            }
  72.  
  73.         typeQuarterFrame=    130;                { MTC quarter frame                                }
  74.          typeCtrl14b        =    131;                { Controlleur 14-bits                            }    
  75.          typeNonRegParam    =    132;                { Non Registred Parameter                        }
  76.          typeRegParam    =    133;                { Registred Parameter                            }
  77.  
  78.          typeSeqNum        =    134;                { numéro de séquence                            }
  79.          typeText        =    135;                { événement texte                                }
  80.          typeCopyright    =    136;                { message copyright                                }
  81.          typeSeqName        =    137;                { nom de séquence ou de piste                    }
  82.          typeInstrName    =    138;                { nom d'instrument                                }
  83.          typeLyric        =    139;                { paroles déstinées à etre chantées                }
  84.          typeMarker        =    140;                { marqueur                                        }
  85.          typeCuePoint    =    141;                { cue point                                        }
  86.          typeChanPrefix    =    142;                { Midi Channel Prefix                            }
  87.          typeEndTrack    =    143;                { fin de piste                                    }
  88.          typeTempo        =    144;                { changement de tempo                            }
  89.          typeSMPTEOffset    =    145;                { offset smpte                                    }
  90.  
  91.          typeTimeSign    =    146;                { indication de mesure                            }
  92.          typeKeySign        =    147;                { signature tonale                                }
  93.          typeSpecific    =    148;                { méta evt spécifique à un séquenceur            }
  94.  
  95.         typeReserved    =    149;    {149..254}    { Codes réservés pour un usage futur            }
  96.         
  97.         typeDead        =    255;                { Evénement privé invalidé                        }
  98.         
  99.  
  100.  
  101. (********************************************************************************)
  102. (*                                     CODES MIDI                                    *)
  103. (*------------------------------------------------------------------------------*)
  104. (* Constantes définissant les codes de statut Midi.                                *)
  105. (********************************************************************************)
  106.     
  107.         NoteOff        =    $80;    
  108.         NoteOn        =    $90;
  109.         PolyTouch    =    $a0;
  110.         ControlChg    =    $b0;
  111.         ProgramChg    =    $c0;
  112.         AfterTouch    =    $d0;
  113.         PitchBend    =    $e0;
  114.         SysRealTime    =    $f0;
  115.         SysEx        =    $f0;
  116.         UnDef1        =    $f1;
  117.         SongPos        =    $f2;
  118.         SongSel        =    $f3;
  119.         UnDef2        =    $f4;
  120.         UnDef3        =    $f5;
  121.         Tune        =    $f6;
  122.         EndSysX        =    $f7;
  123.         MClock        =    $f8;
  124.         UnDef4        =    $f9;
  125.         MStart        =    $fa;
  126.         MCont        =    $fb;
  127.         MStop        =    $fc;
  128.         UnDef5        =    $fd;
  129.         ActSense    =    $fe;
  130.         MReset        =    $ff;
  131.  
  132.  
  133. (********************************************************************************)
  134. (*                                     PORTS MIDI                                    *)
  135. (*------------------------------------------------------------------------------*)
  136. (* Constantes définissant les ports Modem et printer.                            *)
  137. (********************************************************************************)
  138.             
  139.         ModemPort    =     0;
  140.         PrinterPort    =    1;
  141.         
  142.         
  143. (********************************************************************************)
  144. (*                                     CODES D'ERREURS                                *)
  145. (*------------------------------------------------------------------------------*)
  146. (* Constantes définissant les codes d'erreurs renvoyés par certaines fonctions    *)
  147. (* MidiShare.                                                                    *)
  148. (********************************************************************************)
  149.             
  150.         MIDIerrSpace    = -1;        { plus de place dans la freeList ou trop d'applications }
  151.         MIDIerrRefNum    = -2;        { mauvais numéro de reference                 }
  152.         MIDIerrBadType    = -3;        { mauvais type d'événement                     }
  153.         MIDIerrIndex    = -4;        { mauvais index d'accès à un événement         }
  154.         
  155.  
  156. (*******************************************************************************)
  157. (*                                 SYNCHRONISATION CODES                           *)    
  158. (*-----------------------------------------------------------------------------*)
  159. (* List of the error codes returned by some MidiShare functions.               *)                                                    
  160. (*******************************************************************************)
  161.         
  162.         MIDISyncExternal =    $8000;        { bit-15 for external synchronisation     }
  163.         MIDISyncAnyPort     =    $4000;        { bit-14 for synchronisation on any port}
  164.         
  165.  
  166. (********************************************************************************)
  167. (*                                 CODES D'APPLICATIONS                            *)
  168. (*------------------------------------------------------------------------------*)
  169. (* Constantes définissant les codes de modification du statut des applications.    *)
  170. (* Codes utilisés pour signaler à une application toute modification survenue    *)
  171. (* aux autres applications ( ouverture, fermeture, connexion/deconnexion...)    *)
  172. (* Ce code est toujours fourni avec le numéro de référence de l'application     *)
  173. (* modifiée sous la forme d'un longint : $RRRRCCCC (R=refNum, C=code)            *)
  174. (********************************************************************************)
  175.         
  176.         MIDIOpenAppl    = 1;        { ouverture d'une application                }
  177.         MIDICloseAppl    = 2;        { fermeture d'une application                }
  178.         MIDIChgName        = 3;        { changement de nom d'une application        }
  179.         MIDIChgConnect    = 4;        { modification d'une connexion                }
  180.         MIDIOpenModem    = 5;        { ouverture du port Modem                    }
  181.         MIDICloseModem    = 6;        { fermeture du port Modem                    }
  182.         MIDIOpenPrinter    = 7;        { ouverture du port Printer                    }
  183.         MIDIClosePrinter= 8;        { fermeture du port Printer                    }
  184.         MIDISyncStart    = 9;        { début synchronisation                        }
  185.         MIDISyncStop      = 10;        { fin synchronisation                         }
  186.         MIDIChangeSync    = 11;        { changement mode de synchronisation        }
  187.         
  188.         
  189. (********************************************************************************)
  190. (*                             STRUCTURES DES EVENEMENTS                            *)
  191. (*------------------------------------------------------------------------------*)
  192. (* Tous les événements sont construits à l'aide d'une ou plusieurs cellules de    *)
  193. (* taille fixe (16 octets). La plupart nécessitent une seule cellule. D'autres    *)
  194. (* comme les System Exclusive nécessitent plusieurs cellules chaînées.            *)
  195. (********************************************************************************)
  196.         
  197. Type    
  198.         MidiSEXPtr  = ^TMidiSEX;                            
  199.         TMidiSEX    = packed record                    { cellule d'extension d'un sysEx    }
  200.                         link:    MidiSEXPtr;            {     lien de chaînage suivante        }
  201.                         data: PACKED ARRAY[0..11]     {    12 octets de données            }
  202.                                 of byte; 
  203.                          end;
  204.  
  205.         MidiSTPtr      = ^TMidiST;                    
  206.         TMidiST        = packed record                    { Cellule d'extension d'un Private    }
  207.                         ptr1:    ptr;                {    4 pointeurs utilisables            }
  208.                         ptr2:    ptr;                {    librement par les applications    }
  209.                         ptr3:    ptr;
  210.                         ptr4:    ptr;
  211.                          end;
  212.  
  213.         MidiEvPtr  = ^TMidiEv;        
  214.         TMidiEv       = packed record                    { Cellule de base commune à tous    }
  215.                         link:    MidiEvPtr;            {    lien de chaînage à usage interne}
  216.                         date:     longint;            {    date de l'événement en ms        }
  217.                         evType: byte;                {    type de l'événement                }
  218.                         refNum: byte;                {    refNum de l'appl propriétaire    }
  219.                         Port:     byte;                {    port Midi (modem ou printer)    }
  220.                         Chan:    byte;                {    canal Midi                        }
  221.                            case integer of
  222.                         
  223.                             typeNote:
  224.                                (pitch:     byte;        {    hauteur Midi                    }
  225.                                 vel:    byte;        {    vélocité Midi                    }
  226.                                 dur:    integer);    {    durée note en ms                }
  227.                                 
  228.                             typeKeyOn {..typeReset}:
  229.                                (data: PACKED ARRAY[0..3] 
  230.                                            OF byte);     {     octets de données Midi            }
  231.                                
  232.                             typeSysEx {..typeStream}:
  233.                                (linkSE: MidiSEXPtr);{    pointeur cellule d'extension    }
  234.                                
  235.                             typePrivate {..typeProcess}:
  236.                                (linkST: MidiSTPtr);    {     pointeur cellule d'extension    }
  237.                                
  238.                             typeDead:
  239.                                (unused : longint);
  240.                         end;
  241.  
  242.         MidiSeqPtr  = ^TMidiSeq;
  243.         TMidiSeq    = record                        { en tête de séquence                }
  244.                         first:    MidiEvPtr;            {     premier événement de la seq        }
  245.                         last:     MidiEvPtr;            {    dernier événement de la seq        }
  246.                         undef1:    ptr;
  247.                         undef2:    ptr;
  248.                         end;
  249.  
  250.         FilterPtr   = ^TFilter;
  251.         TFilter     = record                                        { filtre d'une application            }
  252.                         port:     packed array [0..255] of boolean;    {  les ports Midi acceptés            }
  253.                         evType:     packed array [0..255] of boolean;    {  les type d'événements acceptés    }
  254.                         channel: packed array [0..15] of boolean;    {  les canaux Midi acceptés            }
  255.                         unused:  packed array [0..15] of boolean;    
  256.                       end;
  257.         
  258.         MidiName    = string[31];                    { Nom d'une application MidiShare (32 octets)        }
  259.         MidiNamePtr    = ^MidiName;
  260.  
  261.         SyncInfoPtr = ^TSyncInfo;
  262.         TSyncInfo    = record
  263.                         time:        longint;
  264.                         reenter:    longint;
  265.                         syncMode:    integer;
  266.                         syncLocked:    byte; 
  267.                         syncPort:    byte;
  268.                         syncStart:    longint;
  269.                         syncStop:    longint;
  270.                         syncOffset:    longint;
  271.                         syncSpeed:    longint;
  272.                         syncBreaks:    longint;
  273.                         syncFormat:    integer;
  274.                     end; 
  275.  
  276.         SmpteLocPtr = ^TSmpteLocation;
  277.         TSmpteLocation    = record
  278.                         format:        integer;
  279.                         hours:        integer;
  280.                         minutes:    integer;
  281.                         seconds:    integer;
  282.                         frames:        integer;
  283.                         fracs:        integer;
  284.                     end; 
  285.     
  286.     
  287.  
  288.  
  289. (********************************************************************************)
  290. (*                         PROCEDURES PASSEES A MIDISHARE                            *)
  291. (*------------------------------------------------------------------------------*)
  292. (* Définition des procédures passées en arguments à MidiShare pour : les alar-    *)
  293. (* mes de réception, les alarmes de contexte, les tâches et le traitement des    *)
  294. (* séquences.                                                                    *)
  295. (********************************************************************************)
  296.         
  297. Type    
  298.         RcvAlarmPtr    = ProcPtr;        { Procedure MyRcvAlarm( refNum:integer )                             }                        
  299.         ApplAlarmPtr= ProcPtr;        { Procedure MyApplAlarm( refNum:integer; code:longint )             }                        
  300.         TaskPtr      = ProcPtr;        { Procedure MyTask( date:longint; refNum:integer; a1,a2,a3:longint )}                        
  301.         ApplyProcPtr= ProcPtr;        { Procedure MyApplyProcPtr( e:MidiEvPtr )                             }
  302.  
  303. (********************************************************************************)
  304. (*                                 POINTS D'ENTREE                                    *)
  305. (*------------------------------------------------------------------------------*)
  306. (* Définition de tous les points d'entrée de MidiShare. Ceux-ci sont implémentés*)
  307. (* par un InLine correspondant à :                                                *)
  308. (*                                                                                *)    
  309. (*            moveq    #nn, d0                                                        *)
  310. (*            move.l    $B8, a0                                                        *)
  311. (*            jsr        (a0)                                                        *)
  312. (*                                                                                *)
  313. (* où nn est le numéro routine MidiShare appelée,et où $B8 (vecteur du trap 14     *)
  314. (* en principe inutilisé) est le point d'ancrage de MidiShare et contient         *)
  315. (* l'adresse d'une routine de dispatch qui réalise l'appel effectif de la         *)
  316. (* fonction. Le vecteur $B8 est initialisé au chargement par MidiShareInit.        *)
  317. (********************************************************************************)
  318.  
  319.  
  320. PROCEDURE    MidiShareSpecialInit;                                            Inline $7037, $2078, $00B8, $4E90;
  321. { Initialisation de MidiShare au chargement. A NE PAS UTILISER PAR LES APPLI    }
  322.  
  323. {------------------}
  324.  
  325. FUNCTION    MidiGetVersion : integer;                                        Inline $7000, $2078, $00B8, $4E90;
  326. { Donne le numéro de version de MidiShare. Ex: pour V1.03 donne 103    }
  327.  
  328. {------------------}
  329.     
  330. FUNCTION    MidiCountAppls : integer;                                        Inline $7001, $2078, $00B8, $4E90;
  331. { Donne le nombre d'applications sous MidiShare actives                }
  332.  
  333. FUNCTION    MidiGetIndAppl (index: integer) : integer;                        Inline $7002, $2078, $00B8, $4E90;
  334. { Donne le refNum de la Nième application                            }
  335.  
  336. FUNCTION    MidiGetNamedAppl (name: midiName) : integer;                    Inline $7003, $2078, $00B8, $4E90;
  337. { Donne le refNum d'une application à partir de son nom                }
  338.  
  339. {------------------}
  340.  
  341. PROCEDURE     MidiGetSyncInfo (p: SyncInfoPtr);                                Inline $7038, $2078, $00B8, $4E90;
  342. { Donne des informations sur l'état de la synchronisation            }
  343.  
  344. PROCEDURE    MidiSetSyncMode (mode: integer);                                Inline $7039, $2078, $00B8, $4E90;
  345. { Permet de configurer la synchronisation                            }
  346.  
  347. FUNCTION    MidiGetExtTime : longint;                                        Inline $703D, $2078, $00B8, $4E90;
  348. { Donne le temps exterieur : celui de la synchro                    }
  349.  
  350. FUNCTION    MidiInt2ExtTime (time: longint) : longint;                        Inline $703E, $2078, $00B8, $4E90;
  351. { Convertit le temps interne (celui de MidiShare) en temps externe (celui de la synchro)                }
  352.  
  353. FUNCTION    MidiExt2IntTime (time: longint) : longint;                        Inline $703F, $2078, $00B8, $4E90;
  354. { Convertit le temps externe (celui de la synchro) en temps interne (celui de MidiShare)                }
  355.  
  356. PROCEDURE     MidiTime2Smpte (time: longint; format: integer; loc: SmpteLocPtr); Inline $7040, $2078, $00B8, $4E90;
  357. { Convertit un temps exprimé en millisecondes en une location SMPTE dont le format est fournis en paramètre }
  358.  
  359. FUNCTION    MidiSmpte2Time (loc: SmpteLocPtr): longint;                        Inline $7041, $2078, $00B8, $4E90;
  360. {convertit une location SMPTE en un temps exprimé en millisecondes }
  361.  
  362.  
  363. FUNCTION    MidiGetTimeAddr : ptr;                                            Inline $7042, $2078, $00B8, $4E90;
  364. {donne l'adresse de la date MidiShare }
  365.  
  366. {------------------}
  367.  
  368. FUNCTION     MidiOpen (applName: midiName): integer;                            Inline $7004, $2078, $00B8, $4E90;
  369. { Ouvre une application et lui donne un nom, renvoie le refNum        }
  370.  
  371. PROCEDURE     MidiClose (refNum: integer);                                    Inline $7005, $2078, $00B8, $4E90;
  372. { Ferme une application                                             }
  373.  
  374. {------------------}
  375.  
  376. FUNCTION     MidiGetName (refNum: integer): MidiNamePtr;                        Inline $7006, $2078, $00B8, $4E90;
  377. { Donne le nom d'une application                                    }
  378.  
  379. PROCEDURE     MidiSetName (refNum: integer; applName: MidiName);                Inline $7007, $2078, $00B8, $4E90;
  380. { Change le nom d'une application                                    }
  381.  
  382. FUNCTION     MidiGetInfo (refNum: integer): ptr;                                Inline $7008, $2078, $00B8, $4E90;
  383. { Donne une Handle associé préalablement à l'application            }
  384.  
  385. PROCEDURE     MidiSetInfo (refNum: integer; InfoZone: ptr);                    Inline $7009, $2078, $00B8, $4E90;
  386. { Associe une Handle à l'application                                }
  387.  
  388. FUNCTION     MidiGetFilter (refNum: integer): FilterPtr;                        Inline $700A, $2078, $00B8, $4E90;
  389. { Donne le filtre associé à une application                            }
  390.  
  391. PROCEDURE     MidiSetFilter (refNum: integer; filter: FilterPtr);                Inline $700B, $2078, $00B8, $4E90;
  392. { Associe un filtre à une application                                }
  393.  
  394. FUNCTION     MidiGetRcvAlarm (refNum: integer): RcvAlarmPtr;                    Inline $700C, $2078, $00B8, $4E90;
  395. { Donne l'alarme de réception associée à une application            }
  396.  
  397. PROCEDURE     MidiSetRcvAlarm (refNum: integer; alarm: RcvAlarmPtr);            Inline $700D, $2078, $00B8, $4E90;
  398. { Associe une alarme de réception à une application                    }
  399.  
  400. FUNCTION     MidiGetApplAlarm (refNum: integer): ApplAlarmPtr;                Inline $700E, $2078, $00B8, $4E90;
  401. { Donne l'alarme de modification associée à une application            }
  402.  
  403. PROCEDURE     MidiSetApplAlarm (refNum: integer; alarm: ApplAlarmPtr);        Inline $700F, $2078, $00B8, $4E90;
  404. { Associe une alarme de modification à une application                }
  405.  
  406. {------------------}
  407.  
  408. PROCEDURE    MidiConnect (src,dest: integer; state: boolean);                Inline $7010, $2078, $00B8, $4E90;
  409. { connecte ou deconnecte deux applications                            }
  410.  
  411. FUNCTION    MidiIsConnected (src,dest: integer) : boolean;                    Inline $7011, $2078, $00B8, $4E90;
  412. { teste la connexion entre deux applications                        }
  413.  
  414. {------------------}
  415.  
  416. FUNCTION     MidiGetPortState (port: integer): boolean;                        Inline $7012, $2078, $00B8, $4E90;
  417. { Donne l'état d'un port Midi, ouvert(true) ou fermé (false)        }
  418.  
  419. PROCEDURE     MidiSetPortState (port: integer; state: boolean);                Inline $7013, $2078, $00B8, $4E90;
  420. { Ouvre (true) ou ferme (false) un port Midi                        }        
  421.  
  422. {------------------}
  423.  
  424. FUNCTION     MidiFreeSpace: longint;                                            Inline $7014, $2078, $00B8, $4E90;
  425. { Donne le nombre de cellules restantes                                }
  426.  
  427. {------------------}
  428.  
  429. FUNCTION     MidiNewEv (typeNum: integer): MidiEvPtr;                        Inline $7015, $2078, $00B8, $4E90;
  430. { Alloue un événement du type souhaité                                }
  431.  
  432. FUNCTION     MidiCopyEv (e: MidiEvPtr): MidiEvPtr;                            Inline $7016, $2078, $00B8, $4E90;
  433. { Copie un événement                                                }
  434.  
  435. PROCEDURE     MidiFreeEv (e: MidiEvPtr);                                        Inline $7017, $2078, $00B8, $4E90;
  436. { Désalloue un événement                                            }        
  437.  
  438. {------------------}
  439.  
  440. PROCEDURE     OldMidiSetField (e: MidiEvPtr; f: integer; v: longint);            Inline $7018, $2078, $00B8, $4E90;
  441. { Change la valeur du Nième champ particulier d'un événement        }
  442.  
  443. FUNCTION    OldMidiGetField (e: MidiEvPtr; f: integer): longint;            Inline $7019, $2078, $00B8, $4E90;
  444. { Donne la valeur du Nième champ particulier d'un événement            }
  445.  
  446. FUNCTION    OldMidiCountFields (e: MidiEvPtr): integer;                        Inline $701B, $2078, $00B8, $4E90;
  447. { Donne le nombre de champs particuliers d'un événement                }
  448.  
  449. PROCEDURE     MidiSetField (e: MidiEvPtr; f: longint; v: longint);            Inline $703A, $2078, $00B8, $4E90;
  450. { Change la valeur du Nième champ particulier d'un événement        }
  451.  
  452. FUNCTION    MidiGetField (e: MidiEvPtr; f: longint): longint;                Inline $703B, $2078, $00B8, $4E90;
  453. { Donne la valeur du Nième champ particulier d'un événement            }
  454.  
  455. PROCEDURE     MidiAddField (e: MidiEvPtr; v: longint);                        Inline $701A, $2078, $00B8, $4E90;
  456. { Ajoute un champ particulier en queue d'un événement (SysEx ou Stream)}
  457.  
  458. FUNCTION    MidiCountFields (e: MidiEvPtr): longint;                        Inline $703C, $2078, $00B8, $4E90;
  459. { Donne le nombre de champs particuliers d'un événement                }
  460.  
  461. {------------------}
  462.  
  463. FUNCTION     MidiNewSeq : MidiSeqPtr;                                         Inline $701D, $2078, $00B8, $4E90;
  464. { Donne une nouvelle séquence (vide)                                }
  465.  
  466. PROCEDURE     MidiAddSeq     (s: MidiSeqPtr; e: MidiEvPtr);                        Inline $701E, $2078, $00B8, $4E90;
  467. { Ajoute un événement à une séquence                                }
  468.  
  469. PROCEDURE     MidiFreeSeq (s: MidiSeqPtr);                                    Inline $701F, $2078, $00B8, $4E90;
  470. { Désalloue la séquence et tous les événements qui s'y trouvent        }
  471.  
  472. PROCEDURE     MidiClearSeq (s: MidiSeqPtr);                                    Inline $7020, $2078, $00B8, $4E90;
  473. { Désalloue tous les événements de la séquence qui devient vide        }
  474.  
  475. PROCEDURE     MidiApplySeq (s: MidiSeqPtr; proc: ApplyProcPtr);                Inline $7021, $2078, $00B8, $4E90;
  476. { Applique une procédure à tous les événements d'une séquence        }
  477.  
  478. {------------------}
  479.  
  480. FUNCTION     MidiGetTime : longint;                                            Inline $7022, $2078, $00B8, $4E90;
  481. { Donne la date courante en millisecondes                            }
  482.  
  483. {------------------}
  484.  
  485. PROCEDURE     MidiSendIm     (refnum: integer; e: MidiEvPtr);                    Inline $7023, $2078, $00B8, $4E90;
  486. { Envoie un événement immédiatement                                    }
  487.  
  488. PROCEDURE    MidiSend     (refnum: integer; e: MidiEvPtr);                    Inline $7024, $2078, $00B8, $4E90;
  489. { Envoie un événement à la date de son champ date                    }
  490.  
  491. PROCEDURE     MidiSendAt     (refnum: integer; e: MidiEvPtr; d: longint);        Inline $7025, $2078, $00B8, $4E90;
  492. { Envoie un événement à la date d                                     }
  493.  
  494. {------------------}
  495.  
  496. FUNCTION    MidiCountEvs (refnum: integer): longint;                        Inline $7026, $2078, $00B8, $4E90;
  497. { Donne le nombre d'événements en attente dans le fifo de l'appl    }
  498.  
  499. FUNCTION    MidiGetEv     (refnum: integer): MidiEvPtr;                        Inline $7027, $2078, $00B8, $4E90;
  500. { Donne l'événement en tête du fifo et l'enlève du fifo                }
  501.  
  502. FUNCTION    MidiAvailEv (refnum: integer): MidiEvPtr;                        Inline $7028, $2078, $00B8, $4E90;
  503. { Donne l'événement en tête du fifo, mais le laisse dedans            }
  504.  
  505. PROCEDURE    MidiFlushEvs (refnum: integer);                                    Inline $7029, $2078, $00B8, $4E90;
  506. { Désalloue tous les événements en attente dans le fifo                }
  507.  
  508. {------------------}
  509.  
  510. FUNCTION     MidiReadSync (adrMem: univ ptr): ptr;                            Inline $702A, $2078, $00B8, $4E90;
  511. { Lit le contenu d'une adresse et la met à NIL (ininterruptible)    }
  512.  
  513. FUNCTION     MidiWriteSync (adrMem: univ ptr; val: univ ptr): ptr;            Inline $702B, $2078, $00B8, $4E90;
  514. { Ecrit le contenu d'une adresse qui n'est pas NIL. Donne l'ancien    }
  515. { contenu. (ininterruptible)                                        }
  516.  
  517. {------------------}
  518.  
  519. PROCEDURE     MidiCall (proc: TaskPtr; date: longint; refNum: integer; a1, a2, a3: longint);
  520.                                                                             Inline $702C, $2078, $00B8, $4E90;
  521. { Appel la procédure proc à la date date et avec les arguments a1, a2,a3}
  522.  
  523. {------------------}
  524. FUNCTION     MidiTask (proc: TaskPtr; date: longint; refNum: integer; a1, a2, a3: longint) : MidiEvPtr;
  525.                                                                             Inline $702D, $2078, $00B8, $4E90;
  526. { Appel la procédure proc à la date date et avec les arguments a1, a2,a3}
  527.  
  528. FUNCTION     MidiDTask (proc: TaskPtr; date: longint; refNum: integer; a1, a2, a3: longint) : MidiEvPtr;
  529.                                                                             Inline $702E, $2078, $00B8, $4E90;
  530. { Appel différé à une procédure proc pour la date date et avec les arguments a1, a2,a3}
  531.  
  532. {------------------}
  533. PROCEDURE    MidiForgetTask (var e: MidiEvPtr);                                Inline $702F, $2078, $00B8, $4E90;
  534. { Essaie d'oublier une tâche    }
  535.  
  536. FUNCTION    MidiCountDTasks (refnum: integer): longint;                        Inline $7030, $2078, $00B8, $4E90;
  537. { Donne le nombre d'événements en attente dans le fifo de l'appl    }
  538.  
  539. PROCEDURE    MidiFlushDTasks (refnum: integer);                                Inline $7031, $2078, $00B8, $4E90;
  540. { Efface toutes les tâches de l'application en attente                }
  541.  
  542. PROCEDURE    MidiExec1DTask (refnum: integer);                                Inline $7032, $2078, $00B8, $4E90;
  543. { Execute la prochaine tâches de l'application en attente            }
  544.  
  545. {------------------}
  546.  
  547. FUNCTION     MidiNewCell : MidiEvPtr;                                        Inline $7033, $2078, $00B8, $4E90;
  548. { Alloue une cellule de base                                        }
  549.  
  550. PROCEDURE     MidiFreeCell (e: MidiEvPtr);                                    Inline $7034, $2078, $00B8, $4E90;
  551. { Désalloue une cellule de base                                        }        
  552.  
  553. {------------------}
  554.  
  555. FUNCTION     MidiTotalSpace: longint;                                        Inline $7035, $2078, $00B8, $4E90;
  556. { Retourne le nombre d'événements alloués par MidiShare                }
  557.  
  558. FUNCTION     MidiGrowSpace (n: longint) : longint;                            Inline $7036, $2078, $00B8, $4E90;
  559. { Augmenter le nb de cell allouées. Retourne le nb effectif.        }
  560.  
  561. {------------------}
  562.  
  563.  
  564. FUNCTION     MidiShare: boolean;
  565. { Test la présence de MidiShare en mémoire                            }
  566.  
  567.  
  568. IMPLEMENTATION
  569.  
  570. FUNCTION     MidiShare: boolean;
  571.     type  longPtr = ^longint;
  572.     var    anchor:    ^longptr;
  573.     begin
  574.         anchor         := pointer($B8);
  575.         MidiShare     := anchor^^=$D080D080    { signature de MidiShare }
  576.     end;
  577.  
  578.  
  579. END.